package cn.edu.hust.cm.lib;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;

// TODO 未完成
/**
 * 在Collections已有静态方法的基础上增加某些有用的静态工具方法
 * 
 * @author 陈明
 * 
 */
public class CollectionsExt {

	/**
	 * 检查一个列表中各元素是否按升序排列
	 * 
	 * @param <T>
	 *            列表list中元素的类型
	 * @param list
	 *            待检查的列表
	 * @return 如果列表list升序排列, 返回true; 否则返回false
	 */
	public static <T extends Comparable<? super T>> boolean isAsc(List<T> list) {

		return false;
	}

	/**
	 * 根据"比较器", 检查一个列表中各元素是否按升序排列
	 * 
	 * @param <T>
	 *            列表list中元素的类型
	 * @param list
	 *            待检查的列表
	 * @param com
	 *            "比较器"
	 * @return 如果列表list升序排列, 返回true; 否则返回false
	 */
	public static <T extends Comparable<? super T>> boolean isAsc(List<T> list,
			Comparator<T> com) {
		return false;
	}

	/**
	 * 检查一个列表中各元素是否按逆序排列
	 * 
	 * @param <T>
	 *            列表list中元素的类型
	 * @param list
	 *            待检查的列表
	 * @return 如果列表list逆序排列, 返回true; 否则返回false
	 */
	public static <T extends Comparable<? super T>> boolean isDesc(List<T> list) {

		return false;
	}

	/**
	 * 根据"比较器", 检查一个列表中各元素是否按逆序排列
	 * 
	 * @param <T>
	 *            列表list中元素的类型
	 * @param list
	 *            待检查的列表
	 * @param com
	 *            "比较器"
	 * @return 如果列表list逆序排列, 返回true; 否则返回false
	 */
	public static <T extends Comparable<? super T>> boolean isDesc(
			List<T> list, Comparator<T> com) {
		return false;
	}

	/**
	 * 将Integer集合转换成int数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的int数组
	 */
	public static int[] collectionToArray(Collection<Integer> co) {
		if (null == co) {
			return null;
		}

		List<Integer> list = new ArrayList<Integer>(co);

		int size = list.size();
		int[] a = new int[size];
		for (int i = 0; i < size; i++) {
			a[i] = list.get(i);
		}
		return a;
	}

	/**
	 * 将Byte集合转换成int数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的byte数组
	 */
	public static byte[] collectionToArray(Collection<Byte> co) {
		if (null == co) {
			return null;
		}

		List<Byte> list = new ArrayList<Byte>(co);

		int size = list.size();
		byte[] a = new byte[size];
		for (int i = 0; i < size; i++) {
			a[i] = list.get(i);
		}
		return a;
	}

	/**
	 * 将Double集合转换成double数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的double数组
	 */
	public static double[] collectionToArray(Collection<Double> co) {
		// TODO
		return null;
	}

	/**
	 * 将Float集合转换成float数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的float数组
	 */
	public static float[] collectionToArray(Collection<Float> co) {
		// TODO
		return null;
	}

	/**
	 * 将Short集合转换成short数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的short数组
	 */
	public static short[] collectionToArray(Collection<Short> co) {
		// TODO
		return null;
	}

	/**
	 * 将Character集合转换成char数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的char数组
	 */
	public static char[] collectionToArray(Collection<Character> co) {
		// TODO
		return null;
	}

	/**
	 * 将Boolean集合转换成boolean数组
	 * 
	 * @param co
	 *            待转换的集合
	 * @return 相应的boolean数组
	 */
	public static boolean[] collectionToArray(Collection<Boolean> co) {
		// TODO
		return null;
	}
}
